github.com/klauspost/compress/flate.fastGen.cur (field)

162 uses

	github.com/klauspost/compress/flate (current package)
		fast_encoder.go#L21: 		return &fastEncL1{fastGen: fastGen{cur: maxStoreBlockSize}}
		fast_encoder.go#L23: 		return &fastEncL2{fastGen: fastGen{cur: maxStoreBlockSize}}
		fast_encoder.go#L25: 		return &fastEncL3{fastGen: fastGen{cur: maxStoreBlockSize}}
		fast_encoder.go#L27: 		return &fastEncL4{fastGen: fastGen{cur: maxStoreBlockSize}}
		fast_encoder.go#L29: 		return &fastEncL5{fastGen: fastGen{cur: maxStoreBlockSize}}
		fast_encoder.go#L31: 		return &fastEncL6{fastGen: fastGen{cur: maxStoreBlockSize}}
		fast_encoder.go#L77: 	cur  int32
		fast_encoder.go#L93: 			e.cur += offset
		fast_encoder.go#L189: 	if e.cur <= bufferReset {
		fast_encoder.go#L190: 		e.cur += maxMatchOffset + int32(len(e.hist))
		level1.go#L24: 	if debugDeflate && e.cur < 0 {
		level1.go#L25: 		panic(fmt.Sprint("e.cur < 0: ", e.cur))
		level1.go#L29: 	for e.cur >= bufferReset {
		level1.go#L34: 			e.cur = maxMatchOffset
		level1.go#L38: 		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
		level1.go#L44: 				v = v - e.cur + maxMatchOffset
		level1.go#L48: 		e.cur = maxMatchOffset
		level1.go#L89: 			e.table[nextHash] = tableEntry{offset: s + e.cur}
		level1.go#L92: 			offset := s - (candidate.offset - e.cur)
		level1.go#L93: 			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level1.go#L94: 				e.table[nextHash] = tableEntry{offset: nextS + e.cur}
		level1.go#L104: 			e.table[nextHash] = tableEntry{offset: s + e.cur}
		level1.go#L106: 			offset = s - (candidate.offset - e.cur)
		level1.go#L107: 			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level1.go#L108: 				e.table[nextHash] = tableEntry{offset: nextS + e.cur}
		level1.go#L123: 			t := candidate.offset - e.cur
		level1.go#L204: 					e.table[hashLen(cv, tableBits, hashBytes)] = tableEntry{offset: s + e.cur}
		level1.go#L216: 			o := e.cur + s - 2
		level1.go#L224: 			offset := s - (candidate.offset - e.cur)
		level1.go#L225: 			if offset > maxMatchOffset || uint32(x) != load3232(src, candidate.offset-e.cur) {
		level2.go#L22: 	if debugDeflate && e.cur < 0 {
		level2.go#L23: 		panic(fmt.Sprint("e.cur < 0: ", e.cur))
		level2.go#L27: 	for e.cur >= bufferReset {
		level2.go#L32: 			e.cur = maxMatchOffset
		level2.go#L36: 		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
		level2.go#L42: 				v = v - e.cur + maxMatchOffset
		level2.go#L46: 		e.cur = maxMatchOffset
		level2.go#L87: 			e.table[nextHash] = tableEntry{offset: s + e.cur}
		level2.go#L90: 			offset := s - (candidate.offset - e.cur)
		level2.go#L91: 			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level2.go#L92: 				e.table[nextHash] = tableEntry{offset: nextS + e.cur}
		level2.go#L102: 			e.table[nextHash] = tableEntry{offset: s + e.cur}
		level2.go#L104: 			offset = s - (candidate.offset - e.cur)
		level2.go#L105: 			if offset < maxMatchOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level2.go#L128: 			t := candidate.offset - e.cur
		level2.go#L160: 					e.table[hashLen(cv, bTableBits, hashBytes)] = tableEntry{offset: s + e.cur}
		level2.go#L169: 				e.table[nextHash] = tableEntry{offset: e.cur + i}
		level2.go#L173: 				e.table[nextHash] = tableEntry{offset: e.cur + i + 2}
		level2.go#L177: 				e.table[nextHash] = tableEntry{offset: e.cur + i + 4}
		level2.go#L187: 			o := e.cur + s - 2
		level2.go#L196: 			offset := s - (candidate.offset - e.cur)
		level2.go#L197: 			if offset > maxMatchOffset || uint32(x>>16) != load3232(src, candidate.offset-e.cur) {
		level3.go#L21: 	if debugDeflate && e.cur < 0 {
		level3.go#L22: 		panic(fmt.Sprint("e.cur < 0: ", e.cur))
		level3.go#L26: 	for e.cur >= bufferReset {
		level3.go#L31: 			e.cur = maxMatchOffset
		level3.go#L35: 		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
		level3.go#L41: 				v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset
		level3.go#L46: 				v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset
		level3.go#L50: 		e.cur = maxMatchOffset
		level3.go#L89: 			minOffset := e.cur + s - (maxMatchOffset - 4)
		level3.go#L90: 			e.table[nextHash] = tableEntryPrev{Prev: candidates.Cur, Cur: tableEntry{offset: s + e.cur}}
		level3.go#L100: 			if uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level3.go#L101: 				if candidates.Prev.offset < minOffset || uint32(cv) != load3232(src, candidates.Prev.offset-e.cur) {
		level3.go#L105: 				offset := s - (candidate.offset - e.cur)
		level3.go#L106: 				o2 := s - (candidates.Prev.offset - e.cur)
		level3.go#L116: 				if candidate.offset > minOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level3.go#L137: 			t := candidate.offset - e.cur
		level3.go#L173: 						Cur:  tableEntry{offset: e.cur + t},
		level3.go#L184: 					Cur:  tableEntry{offset: e.cur + i}}
		level3.go#L193: 				Cur:  tableEntry{offset: e.cur + s - 2},
		level3.go#L200: 				Cur:  tableEntry{offset: e.cur + s - 1},
		level3.go#L208: 				Cur:  tableEntry{offset: s + e.cur},
		level3.go#L213: 			minOffset := e.cur + s - (maxMatchOffset - 4)
		level3.go#L216: 				if uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level3.go#L221: 				if candidate.offset > minOffset && uint32(cv) == load3232(src, candidate.offset-e.cur) {
		level4.go#L17: 	if debugDeflate && e.cur < 0 {
		level4.go#L18: 		panic(fmt.Sprint("e.cur < 0: ", e.cur))
		level4.go#L21: 	for e.cur >= bufferReset {
		level4.go#L29: 			e.cur = maxMatchOffset
		level4.go#L33: 		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
		level4.go#L39: 				v = v - e.cur + maxMatchOffset
		level4.go#L48: 				v = v - e.cur + maxMatchOffset
		level4.go#L52: 		e.cur = maxMatchOffset
		level4.go#L96: 			entry := tableEntry{offset: s + e.cur}
		level4.go#L100: 			t = lCandidate.offset - e.cur
		level4.go#L101: 			if s-t < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.offset-e.cur) {
		level4.go#L106: 			t = sCandidate.offset - e.cur
		level4.go#L107: 			if s-t < maxMatchOffset && uint32(cv) == load3232(src, sCandidate.offset-e.cur) {
		level4.go#L112: 				lOff := nextS - (lCandidate.offset - e.cur)
		level4.go#L113: 				if lOff < maxMatchOffset && load3232(src, lCandidate.offset-e.cur) == uint32(next) {
		level4.go#L117: 						t = lCandidate.offset - e.cur
		level4.go#L172: 				e.table[hashLen(cv, tableBits, hashShortBytes)] = tableEntry{offset: s + e.cur}
		level4.go#L173: 				e.bTable[hash7(cv, tableBits)] = tableEntry{offset: s + e.cur}
		level4.go#L183: 				t := tableEntry{offset: i + e.cur}
		level4.go#L192: 					t := tableEntry{offset: i + e.cur}
		level4.go#L204: 		o := e.cur + s - 1
		level5.go#L17: 	if debugDeflate && e.cur < 0 {
		level5.go#L18: 		panic(fmt.Sprint("e.cur < 0: ", e.cur))
		level5.go#L22: 	for e.cur >= bufferReset {
		level5.go#L30: 			e.cur = maxMatchOffset
		level5.go#L34: 		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
		level5.go#L40: 				v = v - e.cur + maxMatchOffset
		level5.go#L50: 				v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset
		level5.go#L54: 					v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset
		level5.go#L59: 		e.cur = maxMatchOffset
		level5.go#L104: 			entry := tableEntry{offset: s + e.cur}
		level5.go#L112: 			t = lCandidate.Cur.offset - e.cur
		level5.go#L114: 				if uint32(cv) == load3232(src, lCandidate.Cur.offset-e.cur) {
		level5.go#L116: 					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
		level5.go#L118: 					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
		level5.go#L120: 					t2 := lCandidate.Prev.offset - e.cur
		level5.go#L121: 					if s-t2 < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
		level5.go#L132: 				t = lCandidate.Prev.offset - e.cur
		level5.go#L133: 				if s-t < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
		level5.go#L135: 					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
		level5.go#L137: 					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
		level5.go#L142: 			t = sCandidate.offset - e.cur
		level5.go#L143: 			if s-t < maxMatchOffset && uint32(cv) == load3232(src, sCandidate.offset-e.cur) {
		level5.go#L149: 				e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
		level5.go#L151: 				eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
		level5.go#L154: 				t2 := lCandidate.Cur.offset - e.cur
		level5.go#L156: 					if load3232(src, lCandidate.Cur.offset-e.cur) == uint32(next) {
		level5.go#L166: 					t2 = lCandidate.Prev.offset - e.cur
		level5.go#L167: 					if nextS-t2 < maxMatchOffset && load3232(src, lCandidate.Prev.offset-e.cur) == uint32(next) {
		level5.go#L202: 			t2 := eLong - e.cur - l + skipBeginning
		level5.go#L260: 				t := tableEntry{offset: i + e.cur}
		level5.go#L280: 					t := tableEntry{offset: i + e.cur}
		level5.go#L292: 		o := e.cur + s - 1
		level6.go#L17: 	if debugDeflate && e.cur < 0 {
		level6.go#L18: 		panic(fmt.Sprint("e.cur < 0: ", e.cur))
		level6.go#L22: 	for e.cur >= bufferReset {
		level6.go#L30: 			e.cur = maxMatchOffset
		level6.go#L34: 		minOff := e.cur + int32(len(e.hist)) - maxMatchOffset
		level6.go#L40: 				v = v - e.cur + maxMatchOffset
		level6.go#L50: 				v.Cur.offset = v.Cur.offset - e.cur + maxMatchOffset
		level6.go#L54: 					v.Prev.offset = v.Prev.offset - e.cur + maxMatchOffset
		level6.go#L59: 		e.cur = maxMatchOffset
		level6.go#L105: 			entry := tableEntry{offset: s + e.cur}
		level6.go#L114: 			t = lCandidate.Cur.offset - e.cur
		level6.go#L116: 				if uint32(cv) == load3232(src, lCandidate.Cur.offset-e.cur) {
		level6.go#L120: 					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
		level6.go#L122: 					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
		level6.go#L125: 					t2 := lCandidate.Prev.offset - e.cur
		level6.go#L126: 					if s-t2 < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
		level6.go#L138: 				t = lCandidate.Prev.offset - e.cur
		level6.go#L139: 				if s-t < maxMatchOffset && uint32(cv) == load3232(src, lCandidate.Prev.offset-e.cur) {
		level6.go#L141: 					e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
		level6.go#L143: 					eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
		level6.go#L148: 			t = sCandidate.offset - e.cur
		level6.go#L149: 			if s-t < maxMatchOffset && uint32(cv) == load3232(src, sCandidate.offset-e.cur) {
		level6.go#L157: 				e.table[nextHashS] = tableEntry{offset: nextS + e.cur}
		level6.go#L159: 				eLong.Cur, eLong.Prev = tableEntry{offset: nextS + e.cur}, eLong.Cur
		level6.go#L176: 				t2 = lCandidate.Cur.offset - e.cur
		level6.go#L178: 					if load3232(src, lCandidate.Cur.offset-e.cur) == uint32(next) {
		level6.go#L188: 					t2 = lCandidate.Prev.offset - e.cur
		level6.go#L189: 					if nextS-t2 < maxMatchOffset && load3232(src, lCandidate.Prev.offset-e.cur) == uint32(next) {
		level6.go#L225: 			t2 := eLong.Cur.offset - e.cur - l + skipBeginning
		level6.go#L237: 				t2 = eLong.Prev.offset - e.cur - l + skipBeginning
		level6.go#L290: 				e.table[hashLen(cv, tableBits, hashShortBytes)] = tableEntry{offset: i + e.cur}
		level6.go#L292: 				eLong.Cur, eLong.Prev = tableEntry{offset: i + e.cur}, eLong.Cur
		level6.go#L301: 				t := tableEntry{offset: i + e.cur}